import { axiosInstance } from './axiosInstance';
import { API_PATHS } from './apiConfig';
import { GLOBAL_CONFIG } from '../config';
import toastService from './toastService';
import type { ApiResponse, Anime } from '../types/anime';



// 搜索豆瓣动漫
export const getDoubanAnimeSearch = async (query: string): Promise<{data: Anime[], total: number}> => {
  try {
    // 调用后端SpringBoot接口，后端会发起豆瓣请求
    const response = await axiosInstance.get(API_PATHS.DOUBAN.SEARCH, {
      params: {
        q: query  // 后端已修改参数名为q
      }
    });
    
    console.log('豆瓣搜索API返回数据:', response.data);
    
    // 检查响应是否包含data字段和subjects数组
    if (!response.data || !response.data.data || !response.data.data.subjects || !Array.isArray(response.data.data.subjects)) {
      console.error('豆瓣搜索API返回格式异常:', response.data);
      return { data: [], total: 0 };
    }
    
    // 获取后端返回的数据
    const subjects = response.data.data.subjects;
    const total = response.data.data.total || 0;
    
    // 先从原始数据中过滤出动画类型的条目
    const animeSubjects = subjects.filter((subject: any) => 
      Array.isArray(subject.genres) && subject.genres.includes('动画')
    );
    
    // 将动画类型数据转换为标准Anime类型，保持前端对象结构不变
    const filteredResults: Anime[] = animeSubjects.map((subject: any) => {
      // 提取导演信息
      const directors = subject.directors && subject.directors.length > 0 
        ? subject.directors.map((d: any) => d.name).filter(Boolean).join('、') 
        : '';
      
      // 提取类型信息，用顿号连接
      const genres = Array.isArray(subject.genres) ? subject.genres.join('、') : '';
      
      return {
        id: parseInt(subject.id, 10),
        doubanId: subject.id,
        title: subject.title,
        originalTitle: subject.original_title || subject.title,
        description: '', // 搜索结果中不包含描述信息
        synopsis: '',
        releaseDate: subject.year ? `${subject.year}-01-01` : '',
        coverImageUrl: subject.images?.large || subject.images?.medium || subject.images?.small || '',
        rating: subject.rating?.average || 0,
        votes: subject.collect_count || 0,
        year: subject.year ? parseInt(subject.year, 10) : 2024,
        season: '',
        genre: genres,
        director: directors,
        studio: '',
        episodes: 0,
        tags: genres, // 使用类型作为标签
        type: genres
      };
    });
    
    console.log('成功提取到', filteredResults.length, '条动画数据');
    return { 
      data: filteredResults, 
      total: total 
    };
    
  } catch (error) {
    console.error('搜索豆瓣动漫失败:', error);
    return { data: [], total: 0 };
  }
};


// 修复不完整的JSON
// 移除未使用的fixIncompleteJson函数
// function fixIncompleteJson(jsonStr: string, errorPos: number): string | null {
//   try {
//     // 寻找匹配的括号
//     let braceCount = 0;
//     let bracketCount = 0;
//     let inString = false;
//     let escapeNext = false;
//     let lastValidObjectEnd = -1;
//     let lastValidArrayEnd = -1;
//     
//     for (let i = 0; i < jsonStr.length; i++) {
//       const char = jsonStr[i];
//       
//       if (escapeNext) {
//         escapeNext = false;
//         continue;
//       }
//       
//       if (char === '\\') {
//         escapeNext = true;
//         continue;
//       }
//       
//       if (char === '"') {
//         inString = !inString;
//       } else if (!inString) {
//         if (char === '{') braceCount++;
//         else if (char === '}') {
//           braceCount--;
//           if (braceCount === 0 && bracketCount === 0) {
//             lastValidObjectEnd = i + 1;
//           }
//         } else if (char === '[') bracketCount++;
//         else if (char === ']') {
//           bracketCount--;
//           if (braceCount === 0 && bracketCount === 0) {
//             lastValidArrayEnd = i + 1;
//           }
//         }
//       }
//     }
//     
//     // 使用最后一个有效的结束位置
//     const validEnd = Math.max(lastValidObjectEnd, lastValidArrayEnd);
//     if (validEnd > 0) {
//       return jsonStr.substring(0, validEnd);
//     }
//     
//     // 如果找不到有效的结束位置，尝试简单地截取到错误位置前的内容
//     return jsonStr.substring(0, errorPos);
//   } catch (e) {
//     console.error('修复JSON时出错:', e);
//     return null;
//   }
// }





// 获取本月榜单
export const getMonthlyRanking = async (page: number = 1, pageSize: number = 10): Promise<any> => {
  try {
    const response = await axiosInstance.get<ApiResponse<any>>(API_PATHS.ANIME.RANKING, {
      params: {
        page,
        pageSize
      }
    });
    if (response.data.code !== 200) {
      toastService.error(response.data.msg);
      throw new Error(response.data.msg);
    }
    return response.data.data;
  } catch (error) {
    console.error('获取月度榜单失败:', error);
    throw error;
  }
}

// 获取动漫详情
export const getAnimeById = async (id: string): Promise<Anime | null> => {
  try {
    const response = await axiosInstance.get<ApiResponse<Anime>>(API_PATHS.ANIME.BY_ID.replace(':id', id));
    if (response.data.code !== 200) {
      toastService.error(response.data.msg);
      throw new Error(response.data.msg);
    }
    return response.data.data;
  } catch (error) {
    console.error('获取动漫详情失败:', error);
    // 如果返回404，返回null
    if (error instanceof Error && 'response' in error && 
        (error as any).response && (error as any).response.status === 404) {
      return null;
    }
    throw error;
  }
}

// 搜索动漫
export const searchAnimes = async (query: string, page: number = 1, pageSize: number = 12, season?: string, year?: number, genre?: string, sortBy: string = 'rating'): Promise<any> => {
  try {
    // 调用用户的接口获取动漫数据
    const response = await axiosInstance.get<ApiResponse<any>>(API_PATHS.ANIME.ALL, {
      params: {
        query: query || '', // 如果查询参数为空，仍传递空字符串
        page: page,
        pageSize: pageSize,
        season: season,
        year: year,
        genre: genre,
        sortBy: sortBy
      }
    });
    
    if (response.data.code !== 200) {
      toastService.error(response.data.msg);
      throw new Error(response.data.msg);
    }
    
    // 返回完整的分页数据
    return response.data.data;
  } catch (error) {
    console.error('搜索动漫失败:', error);
    throw error;
  }
}

// 从日期字符串中提取季节
// function getSeasonFromDate(dateString: string): string {
//   // 简单的季节映射，实际应用中可能需要更复杂的逻辑
//   const monthMatch = dateString.match(/-(\d{2})-/);
//   if (!monthMatch) return '';
  
//   const month = parseInt(monthMatch[1], 10);
//   if (month >= 1 && month <= 3) return '冬季';
//   if (month >= 4 && month <= 6) return '春季';
//   if (month >= 7 && month <= 9) return '夏季';
//   if (month >= 10 && month <= 12) return '秋季';
  
//   return '';
// }

// 注意：投票功能已迁移到voteService.ts中，此函数已废弃
// 请使用voteService中的voteForAnime函数代替

// 提名动漫
export const nominateAnime = async (anime: Anime): Promise<boolean> => {
  try {
    // 验证必要参数
    if (!anime || !anime.id) {
      console.error('提名失败：缺少必要的动漫ID');
      toastService.error('提名失败：无效的动漫信息');
      return false;
    }
    
    // 处理releaseDate，确保格式为yyyy-mm-dd
    const formattedAnime = { ...anime };
    if (formattedAnime.releaseDate) {
      // 使用正则表达式提取yyyy-mm-dd格式的日期
      const dateMatch = formattedAnime.releaseDate.match(/(\d{4})[-/](\d{1,2})[-/](\d{1,2})/);
      if (dateMatch) {
        // 格式化月和日，确保两位数
        const year = dateMatch[1];
        const month = dateMatch[2].padStart(2, '0');
        const day = dateMatch[3].padStart(2, '0');
        formattedAnime.releaseDate = `${year}-${month}-${day}`;
      } else {
        // 如果无法提取日期，设置为空字符串
        formattedAnime.releaseDate = '';
      }
    }
    
    // 提取原始图片地址，去掉代理前缀
    if (formattedAnime.coverImageUrl) {
      // 检查是否是代理后的地址，如果是则提取原始URL
      const proxyMatch = formattedAnime.coverImageUrl.match(new RegExp(`${API_PATHS.DOUBAN.IMAGE_PROXY}\?url=(.+)`)) || formattedAnime.coverImageUrl.match(/\/api\/image-proxy\?url=(.+)/);
      if (proxyMatch) {
        // 解码URL并使用原始地址
        formattedAnime.coverImageUrl = decodeURIComponent(proxyMatch[1]);
      }
    }
    
    // 构建API路径，替换:animeId占位符
    const apiPath = API_PATHS.ANIME.NOMINATE.replace(':animeId', String(anime.id));
    
    // 发送提名请求到后端API，包含完整的动漫信息
    const response = await axiosInstance.post<ApiResponse<null>>(
      apiPath,
      formattedAnime // 传递处理后的动漫对象作为请求体
    );
    
    // 检查响应状态
    if (response.data.code !== 200) {
      toastService.error(response.data.msg || '提名失败');
      console.error('提名失败:', response.data.msg);
      return false;
    }
    
    return true;
  } catch (error) {
    console.error('提名失败:', error);
    
    // 处理常见错误
    if (error instanceof Error && 'response' in error) {
      const axiosError = error as any;
      if (axiosError.response) {
        // 处理HTTP错误
        switch (axiosError.response.status) {
          case 400:
            // 已经提名过的错误或参数错误
            toastService.error(axiosError.response.data?.msg || '您已经提名过这部动漫了');
            return false;
          case 401:
            // 未登录错误
            toastService.error('请先登录后再提名');
            return false;
          default:
            // 其他HTTP错误
            toastService.error(axiosError.response.data?.msg || '提名失败，请稍后再试');
            return false;
        }
      }
    }
    
    // 网络错误等其他情况
    toastService.error('提名失败，请检查网络连接');
    return false;
  }
}

// 获取用户提名记录
export const getUserNominations = async (page: number = 1, pageSize: number = 9): Promise<{data: Anime[], total: number}> => {
  try {
    const response = await axiosInstance.get<ApiResponse<{data: Anime[], total: number}>>(API_PATHS.NOMINATIONS, {
      params: { page, pageSize }
    });
    if (response.data.code !== 200) {
      toastService.error(response.data.msg);
      throw new Error(response.data.msg);
    }
    // 直接返回response.data.data，因为后端现在返回的是包含data和total的Map对象
    return response.data.data;
  } catch (error) {
    console.error('获取用户提名记录失败:', error);
    // 降级处理：返回空数据和0总数
    return { data: [], total: 0 };
  }
}

// 查询动漫票数
export const getAnimeVoteCount = async (animeId: number): Promise<number> => {
  try {
    const response = await axiosInstance.get<ApiResponse<number>>(
      API_PATHS.VOTE.COUNT.replace(':animeId', animeId.toString())
    );
    if (response.data.code !== 200) {
      toastService.error(response.data.msg);
      throw new Error(response.data.msg);
    }
    return response.data.data;
  } catch (error) {
    console.error('查询动漫票数失败:', error);
    throw error;
  }
}

// 获取用户投票记录
export const getUserVotedAnimes = async (page: number = 1, pageSize: number = 9): Promise<{data: Anime[], total: number}> => {
  try {
    const response = await axiosInstance.get<ApiResponse<{data: Anime[], total: number}>>(API_PATHS.VOTE.USER_LIST, {
      params: { page, pageSize }
    });
    if (response.data.code !== 200) {
      toastService.error(response.data.msg);
      throw new Error(response.data.msg);
    }
    return response.data.data;
  } catch (error) {
    console.error('获取用户投票记录失败:', error);
    // 降级处理：返回空数据和0总数
    return { data: [], total: 0 };
  }
}

// 获取豆瓣动漫详情
export const getDoubanAnimeDetail = async (id: string): Promise<Anime | null> => {
  try {
    // 调用后端SpringBoot接口，后端现在会返回豆瓣API的JSON数据
    const response = await axiosInstance.get(API_PATHS.DOUBAN.DETAIL, {
      params: { id }
    });
    
    // 获取数据（后端返回的数据结构保持不变，但内部内容变为JSON字符串）
    const data = response.data.data || '';
    
    try {
      // 尝试将字符串解析为JSON对象
      const jsonData = typeof data === 'string' ? JSON.parse(data) : data;
      
      // 使用新的JSON解析逻辑
      return parseDoubanDetailJSON(jsonData, id);
    } catch (parseError) {
      console.error('解析JSON数据失败，尝试使用HTML解析作为备用:', parseError);
      // 如果JSON解析失败，尝试使用旧的HTML解析逻辑作为备用
      if (typeof data === 'string' && data.includes('<html>')) {
        return parseDoubanDetailHTML(data, id);
      }
      throw parseError;
    }
  } catch (error) {
    console.error('获取豆瓣动漫详情失败:', error);
    throw error;
  }
};

// 解析豆瓣详情JSON数据提取动漫信息
function parseDoubanDetailJSON(jsonData: any, id: string): Anime {
  // 根据新的后端返回数据结构，需要先访问jsonData.data
  const animeData = jsonData.data || jsonData;
  
  // 从豆瓣API返回的JSON数据中提取所需字段
  const title = animeData.title || '未知标题';
  const originalTitle = animeData.original_title || '';
  const year = animeData.year ? parseInt(animeData.year, 10) : new Date().getFullYear();
  
  // 提取评分信息
  const rating = animeData.rating?.average || 0;
  const votes = animeData.ratings_count || 0;
  
  // 提取类型信息
  const genres = animeData.genres || [];
  const type = genres.join('、') || '';
  
  // 提取封面图片
  const coverImageUrl = animeData.images?.large || animeData.images?.medium || animeData.images?.small || '';
  
  // 提取剧情简介
  const description = animeData.summary || '';
  
  // 提取导演信息
  const directors = animeData.directors || [];
  const director = directors.map((d: any) => d.name).join('、') || '';
  
  // 提取发布日期
  // 根据后端返回数据，使用年份构建默认日期
  let releaseDate = `${year}-01-01`;
  
  // 根据后端返回数据，我们只能获取年份信息，月日使用默认值
  // 在HTML解析模式下会通过parseDoubanDetailHTML函数从页面元素获取精确的首播日期
  // 在JSON解析函数中不应该访问DOM元素，保持已有的日期处理逻辑
  // 暂时不需要处理演员信息
  
  // 暂时不需要处理地区信息
  
  // 提取集数信息（如果有）
  const episodes = animeData.episodes_count ? parseInt(animeData.episodes_count, 10) : 0;
  
  // 构建并返回Anime对象，保持原有数据结构
  return {
    id: parseInt(id, 10),
    doubanId: id,
    title: title,
    originalTitle: originalTitle,
    description: description,
    rating: rating,
    votes: votes,
    year: year,
    releaseDate,
    coverImageUrl: coverImageUrl,
    type: type,
    season: '未知',
    // season: getSeasonFromDate(releaseDate),
    director: director || '',
    // 移除不存在的actors字段
    genre: genres[0] || '',
    // 移除不存在的countries字段
    tags: '',
    // 移除不存在的status字段
    // 移除不存在的duration字段
    episodes: episodes,
    // 移除不存在的watchedEpisodes字段
  };
}

// 解析豆瓣详情页HTML提取动漫信息（作为备用解析方式）
function parseDoubanDetailHTML(html: string, id: string): Anime {
  // 创建一个临时DOM来解析HTML
  const parser = new DOMParser();
  const doc = parser.parseFromString(html, 'text/html');
  
  // 首先尝试从JSON-LD数据中提取信息（这是优先级最高的方式）
  let jsonLdData = null;
  try {
    const jsonLdScript = doc.querySelector('script[type="application/ld+json"]');
    if (jsonLdScript) {
      jsonLdData = JSON.parse(jsonLdScript.textContent || '');
    }
  } catch (e) {
    console.error('解析JSON-LD数据失败:', e);
  }
  
  // 从JSON-LD或页面元素中提取标题信息
  const titleElement = doc.querySelector('h1 span:nth-child(1)');
  const title = jsonLdData?.name ? jsonLdData.name : (titleElement ? titleElement.textContent?.trim() || '未知标题' : '未知标题');
  
  // 提取原始标题
  const originalTitleElement = doc.querySelector('h1 span:nth-child(2)');
  let originalTitle = originalTitleElement ? originalTitleElement.textContent?.trim() || '' : '';
  // 尝试从JSON-LD名称中分离原始标题
  if (!originalTitle && jsonLdData?.name && jsonLdData.name.includes(' ')) {
    // 简单处理：假设名称格式为"中文名称 日文名称"或类似格式
    const nameParts = jsonLdData.name.split(/[\s\u3000]+/);
    if (nameParts.length > 1) {
      originalTitle = nameParts.slice(1).join(' ');
    }
  }
  
  // 提取评分信息（优先从JSON-LD获取）
  let rating = 0;
  let votes = 0;
  if (jsonLdData?.aggregateRating) {
    rating = parseFloat(jsonLdData.aggregateRating.ratingValue || '0');
    votes = parseInt(jsonLdData.aggregateRating.ratingCount || '0', 10);
  } else {
    // 从页面元素获取
    const ratingElement = doc.querySelector('.rating_num');
    rating = ratingElement ? parseFloat(ratingElement.textContent || '0') : 0;
    
    const votesElement = doc.querySelector('.rating_people span');
    const votesText = votesElement ? votesElement.textContent || '0' : '0';
    votes = parseInt(votesText.replace(/[^0-9]/g, ''), 10);
  }
  
  // 提取年份信息
  let year = 2024;
  // 从JSON-LD的发布日期提取年份
  if (jsonLdData?.datePublished) {
    const yearMatch = jsonLdData.datePublished.match(/(\d{4})/);
    if (yearMatch) {
      year = parseInt(yearMatch[1], 10);
    }
  } else {
    // 从页面元素获取
    const yearElement = doc.querySelector('#info span:nth-child(4)');
    if (yearElement) {
      const yearMatch = yearElement.textContent?.match(/(\d{4})/);
      if (yearMatch) {
        year = parseInt(yearMatch[1], 10);
      }
    }
  }
  
  // 提取剧情简介（优先从JSON-LD获取）
  let description = jsonLdData?.description || '';
  
  // 如果JSON-LD中没有简介，尝试多种方式
  if (!description) {
    // 方式1：尝试查找常规的简介元素
    const descriptionElement = doc.querySelector('.related-info .indent span');
    if (descriptionElement) {
      description = descriptionElement.textContent?.trim() || '';
    }
    
    // 方式2：如果方式1失败，尝试查找包含"简介"文本的段落
    if (!description) {
      const contentElements = doc.querySelectorAll('.indent p');
      for (const el of contentElements) {
        const text = el.textContent || '';
        if (text.length > 50) { // 假设简介长度较长
          description = text.trim();
          break;
        }
      }
    }
    
    // 方式3：如果方式1和2都失败，尝试从window.__DATA__中解析
    if (!description) {
      try {
        const dataMatch = html.match(/window\.__DATA__\s*=\s*([^;]+)/);
        if (dataMatch) {
          const dataObj = JSON.parse(dataMatch[1]);
          if (dataObj?.subject?.summary) {
            description = dataObj.subject.summary.trim();
          }
        }
      } catch (e) {
        console.error('解析window.__DATA__失败:', e);
      }
    }
    
    // 方式4：尝试从og:description元标签获取
    if (!description) {
      const ogDescElement = doc.querySelector('meta[property="og:description"]');
      if (ogDescElement) {
        description = ogDescElement.getAttribute('content') || '';
      }
    }
  }
  
  // 提取封面图片
  let coverImageUrl = GLOBAL_CONFIG.DEFAULT_IMAGE_PATH;
  // 优先从JSON-LD获取
  if (jsonLdData?.image) {
    coverImageUrl = jsonLdData.image;
  } else {
    // 从页面元素获取
    const coverElement = doc.querySelector('#mainpic img');
    if (coverElement && coverElement.getAttribute('src')) {
      coverImageUrl = coverElement.getAttribute('src') || '';
    }
  }
  
  // 提取类型信息（优先从JSON-LD获取）
  let genres: string[] = [];
  if (jsonLdData?.genre && Array.isArray(jsonLdData.genre)) {
    genres = jsonLdData.genre.filter(Boolean);
  } else {
    // 从页面元素获取
    const genreElements = doc.querySelectorAll('#info span[property="v:genre"]');
    genres = Array.from(genreElements).map(el => el.textContent || '').filter(Boolean);
  }
  
  // 提取导演信息（优先从JSON-LD获取）
  let directors: string[] = [];
  if (jsonLdData?.director && Array.isArray(jsonLdData.director)) {
    directors = jsonLdData.director.map((d: any) => d.name || '').filter(Boolean);
  } else {
    // 从页面元素获取
    const directorElements = doc.querySelectorAll('#info a[rel="v:directedBy"]');
    directors = Array.from(directorElements).map(el => el.textContent || '').filter(Boolean);
  }
  
  // 提取集数信息（尝试多种方式）
  let episodes = 0;
  // 方式1：尝试通过property属性获取
  const episodesElement = doc.querySelector('#info span[property="v:episode"]');
  if (episodesElement) {
    episodes = parseInt(episodesElement.textContent || '0', 10);
  } else {
    // 方式2：尝试查找包含"集数"文本的元素后面的内容
    const infoElement = doc.querySelector('#info');
    if (infoElement) {
      const infoText = infoElement.textContent || '';
      const episodesMatch = infoText.match(/集数[：:]\s*(\d+)/);
      if (episodesMatch) {
        episodes = parseInt(episodesMatch[1], 10);
      }
    }
  }
  
  // 提取标签信息（从keywords中获取）
  const keywordsElement = doc.querySelector('meta[name="keywords"]');
  let tags: string[] = [];
  if (keywordsElement) {
    const keywords = keywordsElement.getAttribute('content') || '';
    tags = keywords.split(',').filter(Boolean).slice(0, 5); // 只取前5个关键词
  }
  
  // 提取工作室信息（尝试从简介中提取）
  const infoText = doc.querySelector('#info')?.textContent || '';
  let studio = '';
  const studioMatch = infoText.match(/动画制作[:：]\s*(.+?)(?:\n|$)/);
  if (studioMatch) {
    studio = studioMatch[1].trim();
  }
  
  // 提取发布日期
  // 根据后端返回数据，使用年份构建默认日期
  let releaseDate = `${year}-01-01`;
  
  // 先尝试从标准元数据元素获取日期
  if (!releaseDate || releaseDate === `${year}-01-01`) {
    const dateElement = doc.querySelector('#info span[property="v:initialReleaseDate"]');
    if (dateElement) {
      releaseDate = dateElement.textContent?.trim() || `${year}-01-01`;
    }
  }
  
  // 如果仍未获取到日期，尝试从链接元素中提取首播时间信息
  if (!releaseDate || releaseDate === `${year}-01-01`) {
    // 获取info区域内的所有链接元素
    const links = doc.querySelectorAll('#info a');
    for (let i = 0; i < links.length; i++) {
      const linkText = links[i].textContent?.trim() || '';
      // 检查链接文本是否包含年份信息或日期格式
      const yearStr = String(year);
      if ((linkText.includes(yearStr) || /\d{4}[-/]\d{1,2}[-/]\d{1,2}/.test(linkText)) && 
          (linkText.includes('首播') || linkText.includes('上映') || linkText.includes('播出'))) {
        // 提取日期格式（YYYY-MM-DD 或 YYYY/MM/DD）
        const dateMatch = linkText.match(/\d{4}[-/]\d{1,2}[-/]\d{1,2}/);
        if (dateMatch) {
          releaseDate = dateMatch[0].replace('/', '-'); // 统一格式为YYYY-MM-DD
          break;
        } else if (linkText.includes(yearStr)) {
          // 如果只有年份，使用年份加默认月日
          releaseDate = `${year}-01-01`;
          break;
        }
      }
    }
  }
  
  // 构建Anime对象
  return {
    id: parseInt(id, 10) || Date.now(),
    doubanId: id,
    title,
    originalTitle: originalTitle || title,
    description,
    synopsis: description, // 同时设置synopsis字段，确保与description一致
    releaseDate,
    coverImageUrl,
    rating,
    votes,
    year,
    season: '未知',
        // season: getSeasonFromDate(releaseDate),
    genre: genres.join('、'),
    director: directors.join('、'),
    studio,
    episodes,
    tags: tags.join('、'),
    type: genres.length > 0 ? genres.join('、') : '动画' // 添加type字段，使用类型信息
  };
}

// 批量获取动漫详情
export const getAnimesByIds = async (animeIds: number[]): Promise<Anime[]> => {
  try {
    // 如果没有ID，返回空数组
    if (!animeIds || animeIds.length === 0) {
      return [];
    }
    
    // 并行获取所有动漫详情
    const promises = animeIds.map(id => getAnimeById(id.toString()));
    const results = await Promise.all(promises);
    
    // 过滤掉null值并返回有效的动漫对象
    return results.filter((anime): anime is Anime => anime !== null);
  } catch (error) {
    console.error('批量获取动漫详情失败:', error);
    throw error;
  }
}